/**
 * AI分析页面主控制器
 * 统一管理页面功能和状态
 */
class AiAnalysisPage {
    constructor() {
        this.currentTab = 'datasource';
        this.managers = {};
        this.init();
    }
    
    /**
     * 初始化页面
     */
    async init() {
        // 等待DOM加载完成
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', () => this.initialize());
        } else {
            this.initialize();
        }
    }
    
    /**
     * 页面初始化
     */
    async initialize() {
        try {
            console.log('AI分析功能页面初始化开始...');

            // 等待所有必需模块就绪
            if (window.ModuleDependencyManager) {
                console.log('🔍 检查模块依赖...');
                const modulesReady = await window.ModuleDependencyManager.waitForAllRequiredModules();
                if (!modulesReady) {
                    throw new Error('关键模块加载失败，请刷新页面重试');
                }
                console.log('✅ 所有模块已就绪，开始初始化...');
            }

            // 初始化认证管理器（安全检查）
            await this.initializeAuth();

            // 初始化各个管理器
            await this.initializeManagers();

            // 初始化标签页功能
            this.initializeTabs();

            // 初始化数据
            await this.initializeData();

            // 绑定事件
            this.bindEvents();

            console.log('AI分析功能页面初始化完成');

        } catch (error) {
            console.error('页面初始化失败:', error);
            if (window.ErrorHandler) {
                window.ErrorHandler.handleApiError(error, 'page_init');
            } else {
                console.error('错误处理模块未加载:', error);
                alert('页面初始化失败: ' + error.message);
            }
        }
    }
    
    /**
     * 初始化认证管理器
     */
    async initializeAuth() {
        try {
            if (typeof window.authManager !== 'undefined' && window.authManager && typeof window.authManager.checkLoginStatus === 'function') {
                await window.authManager.checkLoginStatus();
            }
        } catch (error) {
            console.warn('认证管理器初始化失败:', error);
            // 不阻止页面继续初始化
        }
    }
    
    /**
     * 初始化各个管理器
     */
    async initializeManagers() {
        // 数据源管理器
        this.managers.datasource = new DataSourceManager();
        // 初始化数据源管理器
        await this.managers.datasource.init();
        // 暴露给全局作用域，供HTML模板使用
        window.dataSourceManager = this.managers.datasource;

        // 分析任务管理器
        this.managers.analysis = new AnalysisManager();
        // 暴露给全局作用域，供HTML模板使用
        window.analysisManager = this.managers.analysis;

        // 污染类型管理器
        if (typeof PollutionTypesManager !== 'undefined') {
            console.log('初始化污染类型管理器...');

            // 使用统一的创建函数，避免重复初始化
            if (typeof createPollutionTypesManager === 'function') {
                try {
                    this.managers.pollutionTypes = createPollutionTypesManager();
                } catch (error) {
                    console.error('创建污染类型管理器失败:', error);
                }
            } else if (window.pollutionTypesManager) {
                // 如果已经存在实例，直接使用
                this.managers.pollutionTypes = window.pollutionTypesManager;
            } else {
                // 如果创建函数不存在，手动创建实例
                try {
                    this.managers.pollutionTypes = new PollutionTypesManager();
                    window.pollutionTypesManager = this.managers.pollutionTypes;
                } catch (error) {
                    console.error('创建污染类型管理器失败:', error);
                }
            }
        } else {
            console.warn('PollutionTypesManager 类未定义');
        }

        // 可以在这里添加其他管理器
        // this.managers.service = new ServiceManager();

        // 在所有管理器创建完成后，进行延迟初始化
        await this.delayedInitManagers();
    }

    /**
     * 延迟初始化管理器 - 确保所有依赖就绪
     */
    async delayedInitManagers() {
        console.log('🚀 开始延迟初始化管理器...');

        try {
            // 初始化分析任务管理器（需要ApiService）
            if (this.managers.analysis && typeof this.managers.analysis.delayedInit === 'function') {
                const analysisSuccess = await this.managers.analysis.delayedInit();
                if (!analysisSuccess) {
                    console.warn('分析任务管理器延迟初始化失败');
                }
            }

            // 初始化污染类型管理器
            if (this.managers.pollutionTypes && typeof this.managers.pollutionTypes.delayedInit === 'function') {
                const pollutionSuccess = await this.managers.pollutionTypes.delayedInit();
                if (!pollutionSuccess) {
                    console.warn('污染类型管理器延迟初始化失败');
                }
            }

            console.log('✅ 管理器延迟初始化完成');
        } catch (error) {
            console.error('❌ 管理器延迟初始化失败:', error);
        }
    }
    
    /**
     * 初始化标签页功能
     */
    initializeTabs() {
        const tabs = document.querySelectorAll('.tab');
        tabs.forEach(tab => {
            tab.addEventListener('click', () => {
                const targetTab = tab.getAttribute('data-tab');
                this.switchTab(targetTab);
            });
        });
        
        // 激活默认标签页
        this.switchTab(this.currentTab);
    }
    
    /**
     * 初始化数据
     */
    async initializeData() {
        try {
            // 根据当前标签页加载对应数据
            switch (this.currentTab) {
                case 'datasource':
                    if (this.managers.datasource) {
                        await this.managers.datasource.loadDatasources();
                    }
                    break;
                case 'analysis':
                    // TODO: 初始化分析数据
                    break;
                case 'service':
                    // TODO: 初始化服务数据
                    break;
                case 'pollution-types':
                    // 污染类型管理器会在自身初始化时加载数据
                    break;
            }
        } catch (error) {
            console.error('初始化数据失败:', error);
            ErrorHandler.handleApiError(error, 'init_data');
        }
    }
    
    /**
     * 绑定全局事件
     */
    bindEvents() {
        // 模态框外部点击关闭
        document.addEventListener('click', (e) => {
            this.handleModalClick(e);
        });
        
        // ESC键关闭模态框
        document.addEventListener('keydown', (e) => {
            if (e.key === 'Escape') {
                this.closeAllModals();
            }
        });
        
        // 数据库类型变化监听
        const dbTypeSelect = document.getElementById('dbType');
        if (dbTypeSelect) {
            dbTypeSelect.addEventListener('change', () => {
                if (this.managers.datasource) {
                    this.managers.datasource.updateDefaultPort();
                }
            });
        }
    }
    
    /**
     * 切换标签页
     */
    switchTab(tabName) {
        // 更新当前标签页
        this.currentTab = tabName;
        
        // 更新标签页样式
        document.querySelectorAll('.tab').forEach(tab => {
            tab.classList.remove('active');
        });
        document.querySelector(`[data-tab="${tabName}"]`).classList.add('active');
        
        // 显示对应内容
        document.querySelectorAll('.tab-content').forEach(content => {
            content.classList.add('hidden');
        });
        const targetContent = document.getElementById(`${tabName}Tab`);
        if (targetContent) {
            targetContent.classList.remove('hidden');
        }
        
        // 加载对应数据
        this.loadTabData(tabName);
    }
    
    /**
     * 加载标签页数据
     */
    async loadTabData(tabName) {
        try {
            switch (tabName) {
                case 'datasource':
                    if (this.managers.datasource) {
                        await this.managers.datasource.loadDatasources();
                    }
                    break;
                case 'analysis':
                    // 加载分析数据
                    if (this.managers.analysis) {
                        this.managers.analysis.refreshTasks();
                    }
                    break;
                case 'service':
                    // TODO: 加载服务数据
                    this.loadServiceData();
                    break;
                case 'pollution-types':
                    // 污染类型数据在管理器初始化时已加载
                    if (this.managers.pollutionTypes) {
                        this.managers.pollutionTypes.refreshData();
                    }
                    break;
            }
        } catch (error) {
            console.error(`加载${tabName}数据失败:`, error);
            ErrorHandler.handleApiError(error, `load_${tabName}_data`);
        }
    }
    
    /**
     * 加载分析数据
     */
    loadAnalysisData() {
        // TODO: 实现分析数据加载逻辑
        console.log('加载分析数据...');
    }
    
    /**
     * 加载服务数据
     */
    loadServiceData() {
        // TODO: 实现服务数据加载逻辑
        console.log('加载服务数据...');
    }
    
    /**
     * 处理模态框点击事件
     */
    handleModalClick(e) {
        const modalId = e.target.id;
        const modalActions = {
            'datasourceDetailModal': () => this.closeDatasourceDetailModal(),
            'addDatasourceModal': () => this.closeAddDatasourceModal(),
            'dataPreviewModal': () => this.closeDataPreviewModal(),
            'addAnalysisModal': () => this.closeAddAnalysisModal(),
            'taskDetailModal': () => this.closeTaskDetailModal(),
            'addServiceModal': () => this.closeAddServiceModal()
        };
        
        if (modalActions[modalId]) {
            modalActions[modalId]();
        }
    }
    
    /**
     * 关闭所有模态框
     */
    closeAllModals() {
        this.closeDatasourceDetailModal();
        this.closeAddDatasourceModal();
        this.closeDataPreviewModal();
        this.closeAddAnalysisModal();
        this.closeTaskDetailModal();
        this.closeAddServiceModal();
    }
    
    /**
     * 显示新增数据源模态框
     */
    showAddDatasourceModal() {
        const modal = document.getElementById('addDatasourceModal');
        if (modal) {
            modal.classList.remove('hidden');
            modal.classList.add('flex');
        }
    }
    
    /**
     * 关闭新增数据源模态框
     */
    closeAddDatasourceModal() {
        const modal = document.getElementById('addDatasourceModal');
        if (modal) {
            modal.classList.add('hidden');
            modal.classList.remove('flex');
            this.resetDatasourceForm();
        }
    }
    
    /**
     * 重置数据源表单
     */
    resetDatasourceForm() {
        document.querySelectorAll('.datasource-type').forEach(el => {
            el.classList.remove('selected');
        });
        
        const databaseConfig = document.getElementById('databaseConfig');
        const excelConfig = document.getElementById('excelConfig');
        if (databaseConfig) databaseConfig.classList.add('hidden');
        if (excelConfig) excelConfig.classList.add('hidden');
        
        // 清空表单字段
        document.querySelectorAll('#addDatasourceModal input, #addDatasourceModal select').forEach(input => {
            if (input.type === 'radio' || input.type === 'checkbox') {
                input.checked = false;
            } else {
                input.value = '';
            }
        });
    }
    
    /**
     * 显示数据源详情
     */
    async showDatasourceDetail(datasourceId) {
        try {
            const response = await ApiService.getDataSource(datasourceId);
            if (response.success) {
                const datasource = response.data;
                this.populateDatasourceDetail(datasource);
                
                const modal = document.getElementById('datasourceDetailModal');
                if (modal) {
                    modal.classList.remove('hidden');
                    modal.classList.add('flex');
                }
            } else {
                ErrorHandler.handleApiError(new Error(response.message || '获取数据源详情失败'), 'get_datasource');
            }
        } catch (error) {
            ErrorHandler.handleApiError(error, 'get_datasource');
        }
    }
    
    /**
     * 填充数据源详情
     */
    populateDatasourceDetail(datasource) {
        // 填充基本信息
        const elements = {
            'detailName': datasource.name,
            'detailDescription': datasource.description || '无描述',
            'detailType': datasource.type === 'database' ? '数据库' : 'Excel文件',
            'detailStatus': datasource.status === 'active' ? '已连接' : '未连接',
            'detailCreated': this.formatDate(datasource.created_at),
            'detailUpdated': this.formatDate(datasource.updated_at)
        };
        
        Object.entries(elements).forEach(([id, value]) => {
            const element = document.getElementById(id);
            if (element) element.textContent = value;
        });
        
        // 填充配置信息
        const configContainer = document.getElementById('detailConfig');
        if (configContainer) {
            const configHtml = this.generateConfigHtml(datasource.config);
            configContainer.innerHTML = configHtml;
        }
    }
    
    /**
     * 生成配置信息HTML
     */
    generateConfigHtml(config) {
        if (!config) return '<p>无配置信息</p>';
        
        const configMap = {
            database: {
                'database_type': '数据库类型',
                'host': '主机地址',
                'port': '端口',
                'database': '数据库名',
                'username': '用户名',
                'schema': 'Schema'
            },
            excel: {
                'file_path': '文件路径',
                'sheet_name': '工作表名',
                'has_header': '包含标题行'
            }
        };
        
        const type = config.type || 'database';
        const fields = configMap[type] || {};
        
        let html = '<div class="space-y-2">';
        Object.entries(fields).forEach(([key, label]) => {
            const value = config[key];
            if (value !== undefined && value !== '') {
                html += `
                    <div class="flex justify-between">
                        <span class="text-slate-600">${label}:</span>
                        <span class="font-medium">${this.formatConfigValue(key, value)}</span>
                    </div>
                `;
            }
        });
        html += '</div>';
        
        return html;
    }
    
    /**
     * 格式化配置值
     */
    formatConfigValue(key, value) {
        if (key === 'password') {
            return '••••••••';
        }
        if (key === 'has_header') {
            return value ? '是' : '否';
        }
        return value;
    }
    
    /**
     * 关闭数据源详情模态框
     */
    closeDatasourceDetailModal() {
        const modal = document.getElementById('datasourceDetailModal');
        if (modal) {
            modal.classList.add('hidden');
            modal.classList.remove('flex');
        }
    }
    
    /**
     * 显示数据预览模态框
     */
    showDataPreviewModal(data) {
        const modal = document.getElementById('dataPreviewModal');
        if (modal) {
            // 填充预览数据
            this.populateDataPreview(data);
            
            modal.classList.remove('hidden');
            modal.classList.add('flex');
        }
    }
    
    /**
     * 填充数据预览内容
     */
    populateDataPreview(data) {
        const previewContainer = document.getElementById('dataPreviewContent');
        if (!previewContainer) return;
        
        if (!data || !data.columns || !data.data) {
            previewContainer.innerHTML = '<p class="text-slate-500">暂无数据</p>';
            return;
        }
        
        // 生成表格HTML
        let html = '<div class="overflow-x-auto">';
        html += '<table class="min-w-full divide-y divide-slate-200">';
        
        // 表头
        html += '<thead class="bg-slate-50">';
        html += '<tr>';
        data.columns.forEach(column => {
            html += `<th class="px-6 py-3 text-left text-xs font-medium text-slate-500 uppercase tracking-wider">${column}</th>`;
        });
        html += '</tr>';
        html += '</thead>';
        
        // 表体
        html += '<tbody class="bg-white divide-y divide-slate-200">';
        data.data.forEach(row => {
            html += '<tr>';
            data.columns.forEach(column => {
                const value = row[column] || '';
                html += `<td class="px-6 py-4 whitespace-nowrap text-sm text-slate-900">${value}</td>`;
            });
            html += '</tr>';
        });
        html += '</tbody>';
        
        html += '</table>';
        html += '</div>';
        
        // 添加统计信息
        html += '<div class="mt-4 p-4 bg-slate-50 rounded-lg">';
        html += `<p class="text-sm text-slate-600">总记录数: <span class="font-medium">${data.total_count || 0}</span></p>`;
        html += `<p class="text-sm text-slate-600">预览记录数: <span class="font-medium">${data.data.length}</span></p>`;
        html += '</div>';
        
        previewContainer.innerHTML = html;
    }
    
    /**
     * 关闭数据预览模态框
     */
    closeDataPreviewModal() {
        const modal = document.getElementById('dataPreviewModal');
        if (modal) {
            modal.classList.add('hidden');
            modal.classList.remove('flex');
        }
        
        // 清理全局变量，避免内存泄漏
        if (window.previewTable) {
            delete window.previewTable;
        }
    }
    
    /**
     * 关闭新增分析模态框
     */
    closeAddAnalysisModal() {
        const modal = document.getElementById('addAnalysisModal');
        if (modal) {
            modal.classList.add('hidden');
            modal.classList.remove('flex');
        }
    }
    
    /**
     * 关闭任务详情模态框
     */
    closeTaskDetailModal() {
        const modal = document.getElementById('taskDetailModal');
        if (modal) {
            modal.classList.add('hidden');
            modal.classList.remove('flex');
        }
    }
    
    /**
     * 关闭新增服务模态框
     */
    closeAddServiceModal() {
        const modal = document.getElementById('addServiceModal');
        if (modal) {
            modal.classList.add('hidden');
            modal.classList.remove('flex');
            this.resetServiceForm();
        }
    }
    
    /**
     * 重置服务表单
     */
    resetServiceForm() {
        document.querySelectorAll('#addServiceModal input, #addServiceModal select').forEach(input => {
            if (input.type === 'radio') {
                input.checked = false;
            } else {
                input.value = '';
            }
        });
        const noneAuthRadio = document.querySelector('input[name="authType"][value="none"]');
        if (noneAuthRadio) noneAuthRadio.checked = true;
    }
    
    /**
     * 格式化日期
     */
    formatDate(dateString) {
        if (!dateString) return '';
        return new Date(dateString).toLocaleString('zh-CN');
    }
}

// 创建全局实例
let aiAnalysisPage;

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', () => {
    aiAnalysisPage = new AiAnalysisPage();
});

// 导出为全局变量
window.AiAnalysisPage = AiAnalysisPage;
window.aiAnalysisPage = aiAnalysisPage;